home *** CD-ROM | disk | FTP | other *** search
/ Champak 61 / Volume 61 - JOGO DISK .iso / Games / i_lost_my_poppy.swf / scripts / DefineSprite_291 / frame_1 / DoAction.as
Text File  |  2008-03-07  |  68KB  |  1,487 lines

  1. var ┬º\x01┬º = 450;
  2. loop0:
  3. while(true)
  4. {
  5.    if(eval("\x01") == 450)
  6.    {
  7.       set("\x01",eval("\x01") + 199);
  8.       ┬º┬ºpush(true);
  9.       continue;
  10.    }
  11.    if(eval("\x01") != 39)
  12.    {
  13.       if(eval("\x01") == 287)
  14.       {
  15.          set("\x01",eval("\x01") + 259);
  16.          stop();
  17.          break;
  18.       }
  19.       if(eval("\x01") == 649)
  20.       {
  21.          set("\x01",eval("\x01") - 610);
  22.          if(┬º┬ºpop())
  23.          {
  24.             set("\x01",eval("\x01") + 249);
  25.          }
  26.       }
  27.       else if(eval("\x01") == 956)
  28.       {
  29.          set("\x01",eval("\x01") - 669);
  30.       }
  31.       else
  32.       {
  33.          if(eval("\x01") != 288)
  34.          {
  35.             if(eval("\x01") == 546)
  36.             {
  37.                set("\x01",eval("\x01") - 546);
  38.                break;
  39.             }
  40.             break;
  41.          }
  42.          set("\x01",eval("\x01") - 1);
  43.       }
  44.       continue;
  45.    }
  46.    set("\x01",eval("\x01") + 249);
  47.    while(true)
  48.    {
  49.       if(┬º┬ºpop() == 502)
  50.       {
  51.          set("\x01",eval("\x01") + 412);
  52.          ┬º┬ºpush(true);
  53.          continue;
  54.       }
  55.       if(eval("\x01") == 336)
  56.       {
  57.          set("\x01",eval("\x01") - 276);
  58.          continue;
  59.       }
  60.       if(eval("\x01") == 874)
  61.       {
  62.          set("\x01",eval("\x01") - 761);
  63.          prevFrame();
  64.          break loop0;
  65.       }
  66.       if(eval("\x01") == 865)
  67.       {
  68.          set("\x01",eval("\x01") - 830);
  69.          break loop0;
  70.       }
  71.       if(eval("\x01") == 551)
  72.       {
  73.          set("\x01",eval("\x01") - 550);
  74.          if(┬º┬ºpop())
  75.          {
  76.             set("\x01",eval("\x01") + 270);
  77.          }
  78.          continue;
  79.       }
  80.       if(eval("\x01") == 914)
  81.       {
  82.          set("\x01",eval("\x01") - 49);
  83.          if(┬º┬ºpop())
  84.          {
  85.             set("\x01",eval("\x01") - 830);
  86.          }
  87.          continue;
  88.       }
  89.       if(eval("\x01") == 486)
  90.       {
  91.          set("\x01",eval("\x01") + 90);
  92.          ┬º┬ºpush(true);
  93.          continue;
  94.       }
  95.       if(eval("\x01") == 585)
  96.       {
  97.          set("\x01",eval("\x01") - 99);
  98.          continue;
  99.       }
  100.       if(eval("\x01") == 35)
  101.       {
  102.          set("\x01",eval("\x01") + 58);
  103.          continue;
  104.       }
  105.       if(eval("\x01") == 247)
  106.       {
  107.          set("\x01",eval("\x01") + 118);
  108.          if(┬º┬ºpop())
  109.          {
  110.             set("\x01",eval("\x01") + 415);
  111.          }
  112.          continue;
  113.       }
  114.       if(eval("\x01") == 576)
  115.       {
  116.          set("\x01",eval("\x01") - 403);
  117.          if(┬º┬ºpop())
  118.          {
  119.             set("\x01",eval("\x01") + 663);
  120.          }
  121.          continue;
  122.       }
  123.       if(eval("\x01") == 416)
  124.       {
  125.          set("\x01",eval("\x01") - 280);
  126.          ┬º┬ºpush(true);
  127.          continue;
  128.       }
  129.       if(eval("\x01") == 266)
  130.       {
  131.          set("\x01",eval("\x01") + 150);
  132.          continue;
  133.       }
  134.       if(eval("\x01") == 667)
  135.       {
  136.          set("\x01",eval("\x01") - 116);
  137.          ┬º┬ºpush(true);
  138.          continue;
  139.       }
  140.       if(eval("\x01") == 150)
  141.       {
  142.          set("\x01",eval("\x01") - 57);
  143.          continue;
  144.       }
  145.       if(eval("\x01") == 93)
  146.       {
  147.          set("\x01",eval("\x01") + 154);
  148.          ┬º┬ºpush(true);
  149.          continue;
  150.       }
  151.       if(eval("\x01") != 549)
  152.       {
  153.          if(eval("\x01") == 780)
  154.          {
  155.             set("\x01",eval("\x01") - 440);
  156.          }
  157.          else if(eval("\x01") == 162)
  158.          {
  159.             set("\x01",eval("\x01") + 123);
  160.             ┬º┬ºpush(true);
  161.          }
  162.          else if(eval("\x01") == 332)
  163.          {
  164.             set("\x01",eval("\x01") + 542);
  165.             if(┬º┬ºpop())
  166.             {
  167.                set("\x01",eval("\x01") - 761);
  168.             }
  169.          }
  170.          else
  171.          {
  172.             if(eval("\x01") == 462)
  173.             {
  174.                set("\x01",eval("\x01") - 139);
  175.                break loop0;
  176.             }
  177.             if(eval("\x01") == 104)
  178.             {
  179.                set("\x01",eval("\x01") + 358);
  180.                if(┬º┬ºpop())
  181.                {
  182.                   set("\x01",eval("\x01") - 139);
  183.                }
  184.             }
  185.             else if(eval("\x01") == 661)
  186.             {
  187.                set("\x01",eval("\x01") - 588);
  188.             }
  189.             else if(eval("\x01") == 271)
  190.             {
  191.                set("\x01",eval("\x01") + 145);
  192.             }
  193.             else if(eval("\x01") == 400)
  194.             {
  195.                set("\x01",eval("\x01") - 238);
  196.             }
  197.             else
  198.             {
  199.                if(eval("\x01") == 365)
  200.                {
  201.                   set("\x01",eval("\x01") + 415);
  202.                   break loop0;
  203.                }
  204.                if(eval("\x01") == 173)
  205.                {
  206.                   set("\x01",eval("\x01") + 663);
  207.                   ┬º┬ºpop() << ┬º┬ºpop() implements ;
  208.                   ┬º┬ºpush(┬º┬ºpop() add ┬º┬ºpop());
  209.                   break loop0;
  210.                }
  211.                if(eval("\x01") == 323)
  212.                {
  213.                   set("\x01",eval("\x01") + 261);
  214.                }
  215.                else if(eval("\x01") == 584)
  216.                {
  217.                   set("\x01",eval("\x01") - 252);
  218.                   ┬º┬ºpush(true);
  219.                }
  220.                else if(eval("\x01") == 982)
  221.                {
  222.                   set("\x01",eval("\x01") - 433);
  223.                   if(┬º┬ºpop())
  224.                   {
  225.                      set("\x01",eval("\x01") - 75);
  226.                   }
  227.                }
  228.                else
  229.                {
  230.                   if(eval("\x01") == 861)
  231.                   {
  232.                      set("\x01",eval("\x01") - 200);
  233.                      break loop0;
  234.                   }
  235.                   if(eval("\x01") == 340)
  236.                   {
  237.                      set("\x01",eval("\x01") + 642);
  238.                      ┬º┬ºpush(true);
  239.                   }
  240.                   else if(eval("\x01") == 285)
  241.                   {
  242.                      set("\x01",eval("\x01") + 576);
  243.                      if(┬º┬ºpop())
  244.                      {
  245.                         set("\x01",eval("\x01") - 200);
  246.                      }
  247.                   }
  248.                   else if(eval("\x01") == 831)
  249.                   {
  250.                      set("\x01",eval("\x01") - 164);
  251.                   }
  252.                   else if(eval("\x01") == 633)
  253.                   {
  254.                      set("\x01",eval("\x01") - 293);
  255.                   }
  256.                   else if(eval("\x01") == 113)
  257.                   {
  258.                      set("\x01",eval("\x01") + 554);
  259.                   }
  260.                   else
  261.                   {
  262.                      if(eval("\x01") == 1)
  263.                      {
  264.                         set("\x01",eval("\x01") + 270);
  265.                         loop9:
  266.                         while(true)
  267.                         {
  268.                            if(┬º┬ºpop())
  269.                            {
  270.                               set("\x01",eval("\x01") - 273);
  271.                            }
  272.                            while(true)
  273.                            {
  274.                               if(eval("\x01") == 486)
  275.                               {
  276.                                  set("\x01",eval("\x01") - 244);
  277.                                  ┬º┬ºpush(true);
  278.                               }
  279.                               else if(eval("\x01") == 388)
  280.                               {
  281.                                  set("\x01",eval("\x01") - 336);
  282.                                  if(┬º┬ºpop())
  283.                                  {
  284.                                     set("\x01",eval("\x01") + 12);
  285.                                  }
  286.                               }
  287.                               else
  288.                               {
  289.                                  if(eval("\x01") == 351)
  290.                                  {
  291.                                     break loop9;
  292.                                  }
  293.                                  if(eval("\x01") == 51)
  294.                                  {
  295.                                     set("\x01",eval("\x01") + 630);
  296.                                  }
  297.                                  else if(eval("\x01") == 70)
  298.                                  {
  299.                                     set("\x01",eval("\x01") + 440);
  300.                                  }
  301.                                  else if(eval("\x01") == 449)
  302.                                  {
  303.                                     set("\x01",eval("\x01") + 14);
  304.                                     if(┬º┬ºpop())
  305.                                     {
  306.                                        set("\x01",eval("\x01") + 86);
  307.                                     }
  308.                                  }
  309.                                  else if(eval("\x01") == 872)
  310.                                  {
  311.                                     set("\x01",eval("\x01") - 731);
  312.                                     if(┬º┬ºpop())
  313.                                     {
  314.                                        set("\x01",eval("\x01") - 71);
  315.                                     }
  316.                                  }
  317.                                  else
  318.                                  {
  319.                                     if(eval("\x01") == 141)
  320.                                     {
  321.                                        set("\x01",eval("\x01") - 71);
  322.                                        break loop0;
  323.                                     }
  324.                                     if(eval("\x01") == 549)
  325.                                     {
  326.                                        set("\x01",eval("\x01") + 331);
  327.                                     }
  328.                                     else if(eval("\x01") == 216)
  329.                                     {
  330.                                        set("\x01",eval("\x01") + 294);
  331.                                     }
  332.                                     else if(eval("\x01") == 129)
  333.                                     {
  334.                                        set("\x01",eval("\x01") + 320);
  335.                                        ┬º┬ºpush(true);
  336.                                     }
  337.                                     else if(eval("\x01") == 196)
  338.                                     {
  339.                                        set("\x01",eval("\x01") - 67);
  340.                                     }
  341.                                     else
  342.                                     {
  343.                                        if(eval("\x01") == 463)
  344.                                        {
  345.                                           set("\x01",eval("\x01") + 86);
  346.                                           break loop0;
  347.                                        }
  348.                                        if(eval("\x01") == 510)
  349.                                        {
  350.                                           set("\x01",eval("\x01") - 122);
  351.                                           ┬º┬ºpush(true);
  352.                                        }
  353.                                        else if(eval("\x01") == 880)
  354.                                        {
  355.                                           set("\x01",eval("\x01") - 8);
  356.                                           ┬º┬ºpush(true);
  357.                                        }
  358.                                        else if(eval("\x01") == 596)
  359.                                        {
  360.                                           set("\x01",eval("\x01") - 467);
  361.                                        }
  362.                                        else
  363.                                        {
  364.                                           if(eval("\x01") == 52)
  365.                                           {
  366.                                              set("\x01",eval("\x01") + 12);
  367.                                              break loop0;
  368.                                           }
  369.                                           if(eval("\x01") == 832)
  370.                                           {
  371.                                              set("\x01",eval("\x01") - 151);
  372.                                           }
  373.                                           else if(eval("\x01") == 39)
  374.                                           {
  375.                                              set("\x01",eval("\x01") + 841);
  376.                                           }
  377.                                           else if(eval("\x01") == 284)
  378.                                           {
  379.                                              set("\x01",eval("\x01") + 67);
  380.                                              if(┬º┬ºpop())
  381.                                              {
  382.                                                 set("\x01",eval("\x01") - 300);
  383.                                              }
  384.                                           }
  385.                                           else
  386.                                           {
  387.                                              if(eval("\x01") == 242)
  388.                                              {
  389.                                                 break;
  390.                                              }
  391.                                              if(eval("\x01") == 64)
  392.                                              {
  393.                                                 set("\x01",eval("\x01") + 608);
  394.                                              }
  395.                                              else
  396.                                              {
  397.                                                 if(eval("\x01") == 140)
  398.                                                 {
  399.                                                    set("\x01",eval("\x01") + 56);
  400.                                                    ┬º┬ºpop() implements ;
  401.                                                    break loop0;
  402.                                                 }
  403.                                                 if(eval("\x01") == 681)
  404.                                                 {
  405.                                                    set("\x01",eval("\x01") - 41);
  406.                                                    ┬º┬ºpush(true);
  407.                                                 }
  408.                                                 else if(eval("\x01") == 452)
  409.                                                 {
  410.                                                    set("\x01",eval("\x01") + 220);
  411.                                                 }
  412.                                                 else if(eval("\x01") == 640)
  413.                                                 {
  414.                                                    set("\x01",eval("\x01") - 500);
  415.                                                    if(┬º┬ºpop())
  416.                                                    {
  417.                                                       set("\x01",eval("\x01") + 56);
  418.                                                    }
  419.                                                 }
  420.                                                 else
  421.                                                 {
  422.                                                    if(eval("\x01") == 672)
  423.                                                    {
  424.                                                       set("\x01",eval("\x01") - 65);
  425.                                                       stop();
  426.                                                       break loop0;
  427.                                                    }
  428.                                                    if(eval("\x01") == 339)
  429.                                                    {
  430.                                                       set("\x01",eval("\x01") - 55);
  431.                                                       ┬º┬ºpush(true);
  432.                                                    }
  433.                                                    else if(eval("\x01") == 921)
  434.                                                    {
  435.                                                       set("\x01",eval("\x01") - 582);
  436.                                                    }
  437.                                                    else
  438.                                                    {
  439.                                                       if(eval("\x01") == 607)
  440.                                                       {
  441.                                                          set("\x01",eval("\x01") - 607);
  442.                                                          break loop0;
  443.                                                       }
  444.                                                       if(eval("\x01") != 209)
  445.                                                       {
  446.                                                          if(eval("\x01") == 482)
  447.                                                          {
  448.                                                             set("\x01",eval("\x01") - 273);
  449.                                                             prevFrame();
  450.                                                             break loop0;
  451.                                                          }
  452.                                                          break loop0;
  453.                                                       }
  454.                                                       set("\x01",eval("\x01") + 130);
  455.                                                    }
  456.                                                 }
  457.                                              }
  458.                                           }
  459.                                        }
  460.                                     }
  461.                                  }
  462.                               }
  463.                            }
  464.                            set("\x01",eval("\x01") + 240);
  465.                         }
  466.                         set("\x01",eval("\x01") - 300);
  467.                         loop11:
  468.                         while(true)
  469.                         {
  470.                            set(┬º┬ºpop(),┬º┬ºpop() - 135);
  471.                            if(┬º┬ºpop())
  472.                            {
  473.                               set("\x01",eval("\x01") + 675);
  474.                            }
  475.                            while(true)
  476.                            {
  477.                               if(eval("\x01") != 185)
  478.                               {
  479.                                  if(eval("\x01") != 262)
  480.                                  {
  481.                                     if(eval("\x01") != 179)
  482.                                     {
  483.                                        if(eval("\x01") != 592)
  484.                                        {
  485.                                           if(eval("\x01") != 639)
  486.                                           {
  487.                                              if(eval("\x01") != 993)
  488.                                              {
  489.                                                 if(eval("\x01") != 463)
  490.                                                 {
  491.                                                    if(eval("\x01") != 685)
  492.                                                    {
  493.                                                       if(eval("\x01") != 994)
  494.                                                       {
  495.                                                          if(eval("\x01") != 5)
  496.                                                          {
  497.                                                             if(eval("\x01") != 548)
  498.                                                             {
  499.                                                                if(eval("\x01") == 541)
  500.                                                                {
  501.                                                                   set("\x01",eval("\x01") - 56);
  502.                                                                   prevFrame();
  503.                                                                   break loop0;
  504.                                                                }
  505.                                                                if(eval("\x01") == 55)
  506.                                                                {
  507.                                                                   set("\x01",eval("\x01") + 475);
  508.                                                                   if(┬º┬ºpop())
  509.                                                                   {
  510.                                                                      set("\x01",eval("\x01") + 464);
  511.                                                                   }
  512.                                                                   continue;
  513.                                                                }
  514.                                                                if(eval("\x01") == 287)
  515.                                                                {
  516.                                                                   set("\x01",eval("\x01") + 387);
  517.                                                                   continue;
  518.                                                                   continue;
  519.                                                                }
  520.                                                                if(eval("\x01") == 822)
  521.                                                                {
  522.                                                                   set("\x01",eval("\x01") - 373);
  523.                                                                   continue;
  524.                                                                }
  525.                                                                if(eval("\x01") == 502)
  526.                                                                {
  527.                                                                   set("\x01",eval("\x01") + 484);
  528.                                                                   continue;
  529.                                                                   continue;
  530.                                                                }
  531.                                                                if(eval("\x01") == 385)
  532.                                                                {
  533.                                                                   break loop11;
  534.                                                                }
  535.                                                             }
  536.                                                             set("\x01",eval("\x01") - 540);
  537.                                                             continue;
  538.                                                             if(eval("\x01") != 94)
  539.                                                             {
  540.                                                                if(eval("\x01") != 667)
  541.                                                                {
  542.                                                                   if(eval("\x01") == 976)
  543.                                                                   {
  544.                                                                      set("\x01",eval("\x01") - 309);
  545.                                                                      setProperty(┬º┬ºpop(), _X, ┬º┬ºpop());
  546.                                                                      break loop0;
  547.                                                                   }
  548.                                                                   if(eval("\x01") != 670)
  549.                                                                   {
  550.                                                                      if(eval("\x01") != 135)
  551.                                                                      {
  552.                                                                         if(eval("\x01") == 530)
  553.                                                                         {
  554.                                                                            set("\x01",eval("\x01") + 464);
  555.                                                                            break loop0;
  556.                                                                         }
  557.                                                                         if(eval("\x01") == 121)
  558.                                                                         {
  559.                                                                            set("\x01",eval("\x01") + 264);
  560.                                                                            if(┬º┬ºpop())
  561.                                                                            {
  562.                                                                               set("\x01",eval("\x01") + 163);
  563.                                                                            }
  564.                                                                            continue;
  565.                                                                         }
  566.                                                                         if(eval("\x01") == 674)
  567.                                                                         {
  568.                                                                            set("\x01",eval("\x01") - 619);
  569.                                                                            ┬º┬ºpush(true);
  570.                                                                            continue;
  571.                                                                         }
  572.                                                                         if(eval("\x01") == 485)
  573.                                                                         {
  574.                                                                            set("\x01",eval("\x01") - 22);
  575.                                                                            continue;
  576.                                                                            continue;
  577.                                                                         }
  578.                                                                         if(eval("\x01") == 619)
  579.                                                                         {
  580.                                                                            set("\x01",eval("\x01") + 357);
  581.                                                                            if(┬º┬ºpop())
  582.                                                                            {
  583.                                                                               set("\x01",eval("\x01") - 309);
  584.                                                                            }
  585.                                                                            continue;
  586.                                                                         }
  587.                                                                         if(eval("\x01") == 8)
  588.                                                                         {
  589.                                                                            set("\x01",eval("\x01") + 633);
  590.                                                                            ┬º┬ºpush(true);
  591.                                                                            continue;
  592.                                                                         }
  593.                                                                         if(eval("\x01") == 382)
  594.                                                                         {
  595.                                                                            set("\x01",eval("\x01") - 95);
  596.                                                                            break loop0;
  597.                                                                         }
  598.                                                                      }
  599.                                                                      set("\x01",eval("\x01") - 127);
  600.                                                                      continue;
  601.                                                                      if(eval("\x01") != 755)
  602.                                                                      {
  603.                                                                         if(eval("\x01") == 282)
  604.                                                                         {
  605.                                                                            break;
  606.                                                                         }
  607.                                                                         if(eval("\x01") == 986)
  608.                                                                         {
  609.                                                                            set("\x01",eval("\x01") - 367);
  610.                                                                            ┬º┬ºpush(true);
  611.                                                                            continue;
  612.                                                                         }
  613.                                                                         if(eval("\x01") != 77)
  614.                                                                         {
  615.                                                                            if(eval("\x01") != 641)
  616.                                                                            {
  617.                                                                               if(eval("\x01") == 147)
  618.                                                                               {
  619.                                                                                  set("\x01",eval("\x01") + 675);
  620.                                                                                  break loop0;
  621.                                                                               }
  622.                                                                               if(eval("\x01") == 449)
  623.                                                                               {
  624.                                                                                  set("\x01",eval("\x01") + 530);
  625.                                                                                  stop();
  626.                                                                                  break loop0;
  627.                                                                               }
  628.                                                                               if(eval("\x01") == 979)
  629.                                                                               {
  630.                                                                                  set("\x01",eval("\x01") - 979);
  631.                                                                                  break loop0;
  632.                                                                               }
  633.                                                                            }
  634.                                                                            set("\x01",eval("\x01") - 259);
  635.                                                                            if(┬º┬ºpop())
  636.                                                                            {
  637.                                                                               set("\x01",eval("\x01") - 95);
  638.                                                                            }
  639.                                                                         }
  640.                                                                         set("\x01",eval("\x01") + 205);
  641.                                                                         ┬º┬ºpush(true);
  642.                                                                      }
  643.                                                                      set("\x01",eval("\x01") + 238);
  644.                                                                   }
  645.                                                                   set("\x01",eval("\x01") - 207);
  646.                                                                   if(eval("\t") == 6)
  647.                                                                   {
  648.                                                                      ┬º┬ºpush(chr(┬º┬ºpop()));
  649.                                                                      break loop0;
  650.                                                                   }
  651.                                                                   continue;
  652.                                                                }
  653.                                                                set("\x01",eval("\x01") - 488);
  654.                                                                continue;
  655.                                                                if(┬º┬ºpop())
  656.                                                                {
  657.                                                                   set("\x01",eval("\x01") - 899);
  658.                                                                }
  659.                                                             }
  660.                                                          }
  661.                                                          set("\x01",eval("\x01") + 444);
  662.                                                          continue;
  663.                                                          set("\x01",eval("\x01") + 892);
  664.                                                       }
  665.                                                       set("\x01",eval("\x01") - 917);
  666.                                                       continue;
  667.                                                    }
  668.                                                    set("\x01",eval("\x01") - 11);
  669.                                                    continue;
  670.                                                 }
  671.                                                 set("\x01",eval("\x01") + 292);
  672.                                                 ┬º┬ºpush(true);
  673.                                                 continue;
  674.                                              }
  675.                                              set("\x01",eval("\x01") - 323);
  676.                                              set("\t",6);
  677.                                              continue;
  678.                                           }
  679.                                           set("\x01",eval("\x01") - 460);
  680.                                           continue;
  681.                                        }
  682.                                        set("\x01",eval("\x01") - 51);
  683.                                        if(┬º┬ºpop())
  684.                                        {
  685.                                           set("\x01",eval("\x01") - 56);
  686.                                        }
  687.                                        continue;
  688.                                     }
  689.                                     set("\x01",eval("\x01") - 58);
  690.                                     ┬º┬ºpush(true);
  691.                                     continue;
  692.                                  }
  693.                                  set("\x01",eval("\x01") - 185);
  694.                                  continue;
  695.                               }
  696.                               set("\x01",eval("\x01") + 407);
  697.                               ┬º┬ºpush(true);
  698.                            }
  699.                         }
  700.                         set("\x01",eval("\x01") + 163);
  701.                         break loop0;
  702.                      }
  703.                      if(eval("\x01") == 73)
  704.                      {
  705.                         set("\x01",eval("\x01") + 346);
  706.                         stop();
  707.                         break loop0;
  708.                      }
  709.                      if(eval("\x01") == 60)
  710.                      {
  711.                         set("\x01",eval("\x01") + 44);
  712.                         ┬º┬ºpush(true);
  713.                      }
  714.                      else if(eval("\x01") == 474)
  715.                      {
  716.                         set("\x01",eval("\x01") - 414);
  717.                      }
  718.                      else if(eval("\x01") == 56)
  719.                      {
  720.                         set("\x01",eval("\x01") + 528);
  721.                      }
  722.                      else if(eval("\x01") == 136)
  723.                      {
  724.                         set("\x01",eval("\x01") + 83);
  725.                         if(┬º┬ºpop())
  726.                         {
  727.                            set("\x01",eval("\x01") + 366);
  728.                         }
  729.                      }
  730.                      else if(eval("\x01") == 836)
  731.                      {
  732.                         set("\x01",eval("\x01") - 674);
  733.                      }
  734.                      else
  735.                      {
  736.                         if(eval("\x01") == 219)
  737.                         {
  738.                            set("\x01",eval("\x01") + 366);
  739.                            break loop0;
  740.                         }
  741.                         if(eval("\x01") == 174)
  742.                         {
  743.                            set("\x01",eval("\x01") - 101);
  744.                         }
  745.                         else
  746.                         {
  747.                            if(eval("\x01") != 932)
  748.                            {
  749.                               if(eval("\x01") == 419)
  750.                               {
  751.                                  set("\x01",eval("\x01") - 419);
  752.                                  break loop0;
  753.                               }
  754.                               break loop0;
  755.                            }
  756.                            set("\x01",eval("\x01") - 446);
  757.                         }
  758.                      }
  759.                   }
  760.                }
  761.             }
  762.          }
  763.          continue;
  764.       }
  765.       set("\x01",eval("\x01") - 75);
  766.       loop2:
  767.       while(true)
  768.       {
  769.          set(┬º┬ºpop(),┬º┬ºpop() + 320);
  770.          if(┬º┬ºpop())
  771.          {
  772.             set("\x01",eval("\x01") - 205);
  773.          }
  774.          loop3:
  775.          while(true)
  776.          {
  777.             if(eval("\x01") == 370)
  778.             {
  779.                set("\x01",eval("\x01") - 39);
  780.                ┬º┬ºpush(true);
  781.                continue;
  782.             }
  783.             if(eval("\x01") == 424)
  784.             {
  785.                set("\x01",eval("\x01") + 41);
  786.                continue;
  787.             }
  788.             if(eval("\x01") == 960)
  789.             {
  790.                set("\x01",eval("\x01") - 312);
  791.                break loop0;
  792.             }
  793.             if(eval("\x01") == 248)
  794.             {
  795.                set("\x01",eval("\x01") + 196);
  796.                if(┬º┬ºpop())
  797.                {
  798.                   set("\x01",eval("\x01") + 475);
  799.                }
  800.                continue;
  801.             }
  802.             if(eval("\x01") == 207)
  803.             {
  804.                set("\x01",eval("\x01") + 691);
  805.                if(┬º┬ºpop())
  806.                {
  807.                   set("\x01",eval("\x01") - 758);
  808.                }
  809.                continue;
  810.             }
  811.             if(eval("\x01") == 393)
  812.             {
  813.                set("\x01",eval("\x01") + 567);
  814.                if(┬º┬ºpop())
  815.                {
  816.                   set("\x01",eval("\x01") - 312);
  817.                }
  818.                continue;
  819.             }
  820.             if(eval("\x01") == 413)
  821.             {
  822.                set("\x01",eval("\x01") + 581);
  823.                continue;
  824.             }
  825.             if(eval("\x01") == 509)
  826.             {
  827.                set("\x01",eval("\x01") - 48);
  828.                break loop0;
  829.             }
  830.             if(eval("\x01") == 994)
  831.             {
  832.                set("\x01",eval("\x01") - 787);
  833.                ┬º┬ºpush(true);
  834.                continue;
  835.             }
  836.             if(eval("\x01") == 183)
  837.             {
  838.                set("\x01",eval("\x01") + 210);
  839.                ┬º┬ºpush(true);
  840.                continue;
  841.             }
  842.             if(eval("\x01") == 825)
  843.             {
  844.                set("\x01",eval("\x01") - 205);
  845.                ┬º┬ºpush(new ┬º\┬º\┬ºpop()┬º());
  846.                break loop0;
  847.             }
  848.             if(eval("\x01") == 322)
  849.             {
  850.                set("\x01",eval("\x01") + 673);
  851.                play();
  852.                toggleHighQuality();
  853.                ┬º┬ºpush(mbchr(┬º┬ºpop() add ┬º┬ºpop()));
  854.                break loop0;
  855.             }
  856.             ┬º┬ºpush(eval("\x01"));
  857.             ┬º┬ºpush(505);
  858.             loop4:
  859.             for(; ┬º┬ºpop() != ┬º┬ºpop(); set("\x01",eval("\x01") + 38),stop())
  860.             {
  861.                if(eval("\x01") == 245)
  862.                {
  863.                   set("\x01",eval("\x01") + 217);
  864.                   continue loop3;
  865.                }
  866.                if(eval("\x01") == 846)
  867.                {
  868.                   set("\x01",eval("\x01") - 381);
  869.                   continue loop3;
  870.                }
  871.                if(eval("\x01") == 919)
  872.                {
  873.                   set("\x01",eval("\x01") + 75);
  874.                   continue loop3;
  875.                }
  876.                if(eval("\x01") == 140)
  877.                {
  878.                   set("\x01",eval("\x01") + 530);
  879.                   continue loop3;
  880.                }
  881.                if(eval("\x01") == 959)
  882.                {
  883.                   set("\x01",eval("\x01") - 2);
  884.                   break loop0;
  885.                }
  886.                if(eval("\x01") == 612)
  887.                {
  888.                   set("\x01",eval("\x01") - 290);
  889.                   if(┬º┬ºpop())
  890.                   {
  891.                      set("\x01",eval("\x01") + 673);
  892.                   }
  893.                   continue loop3;
  894.                }
  895.                if(eval("\x01") == 694)
  896.                {
  897.                   set("\x01",eval("\x01") + 181);
  898.                   continue loop3;
  899.                }
  900.                if(eval("\x01") == 875)
  901.                {
  902.                   set("\x01",eval("\x01") - 263);
  903.                   ┬º┬ºpush(true);
  904.                   continue loop3;
  905.                }
  906.                if(eval("\x01") == 898)
  907.                {
  908.                   set("\x01",eval("\x01") - 758);
  909.                   gotoAndStop("∩┐╜∩┐╜R_~~K{∩┐╜2\x12TaKk∩┐╜\x0b>∩┐╜)∩┐╜∩┐╜∩┐╜∩┐╜M∩┐╜X∩┐╜┬¿\\E∩┐╜±ñ║╕Y∩┐╜▀▒6:t∩┐╜\x14∩┐╜7∩┐╜\x1c∩┐╜\x12∩┐╜∩┐╜∩┐╜J\x1c\x16∩┐╜∩┐╜");
  910.                   break loop0;
  911.                }
  912.                if(eval("\x01") == 957)
  913.                {
  914.                   set("\x01",eval("\x01") - 774);
  915.                   continue loop3;
  916.                }
  917.                if(eval("\x01") == 321)
  918.                {
  919.                   set("\x01",eval("\x01") + 468);
  920.                   break loop0;
  921.                }
  922.                if(eval("\x01") == 769)
  923.                {
  924.                   set("\x01",eval("\x01") - 99);
  925.                   continue loop3;
  926.                }
  927.                if(eval("\x01") == 465)
  928.                {
  929.                   set("\x01",eval("\x01") - 48);
  930.                   ┬º┬ºpush(true);
  931.                   continue loop3;
  932.                }
  933.                if(eval("\x01") == 191)
  934.                {
  935.                   set("\x01",eval("\x01") + 523);
  936.                   if(eval("\t") == 17)
  937.                   {
  938.                      break loop0;
  939.                   }
  940.                   continue loop3;
  941.                }
  942.                if(eval("\x01") == 444)
  943.                {
  944.                   set("\x01",eval("\x01") + 475);
  945.                   break loop0;
  946.                }
  947.                if(eval("\x01") == 620)
  948.                {
  949.                   set("\x01",eval("\x01") + 10);
  950.                   continue loop3;
  951.                }
  952.                if(eval("\x01") == 670)
  953.                {
  954.                   set("\x01",eval("\x01") - 128);
  955.                   ┬º┬ºpush(true);
  956.                   continue loop3;
  957.                }
  958.                if(eval("\x01") == 943)
  959.                {
  960.                   set("\x01",eval("\x01") - 752);
  961.                   set("\t",17);
  962.                   continue loop3;
  963.                }
  964.                if(eval("\x01") == 819)
  965.                {
  966.                   set("\x01",eval("\x01") + 56);
  967.                   continue loop3;
  968.                }
  969.                if(eval("\x01") == 542)
  970.                {
  971.                   set("\x01",eval("\x01") + 401);
  972.                   if(┬º┬ºpop())
  973.                   {
  974.                      set("\x01",eval("\x01") - 519);
  975.                   }
  976.                   continue loop3;
  977.                }
  978.                if(eval("\x01") == 461)
  979.                {
  980.                   set("\x01",eval("\x01") + 25);
  981.                   continue loop3;
  982.                }
  983.                if(eval("\x01") == 995)
  984.                {
  985.                   set("\x01",eval("\x01") - 533);
  986.                   continue loop3;
  987.                }
  988.                if(eval("\x01") == 462)
  989.                {
  990.                   set("\x01",eval("\x01") - 183);
  991.                   this.gotoAndPlay(8);
  992.                   break loop0;
  993.                }
  994.                if(eval("\x01") == 763)
  995.                {
  996.                   set("\x01",eval("\x01") - 277);
  997.                   continue loop3;
  998.                }
  999.                if(eval("\x01") == 789)
  1000.                {
  1001.                   set("\x01",eval("\x01") - 75);
  1002.                   continue loop3;
  1003.                }
  1004.                if(eval("\x01") == 630)
  1005.                {
  1006.                   set("\x01",eval("\x01") + 160);
  1007.                   ┬º┬ºpush(true);
  1008.                   continue loop3;
  1009.                }
  1010.                if(eval("\x01") == 417)
  1011.                {
  1012.                   set("\x01",eval("\x01") - 51);
  1013.                   if(┬º┬ºpop())
  1014.                   {
  1015.                      set("\x01",eval("\x01") + 328);
  1016.                   }
  1017.                   continue loop3;
  1018.                }
  1019.                if(eval("\x01") == 790)
  1020.                {
  1021.                   set("\x01",eval("\x01") - 469);
  1022.                   if(┬º┬ºpop())
  1023.                   {
  1024.                      set("\x01",eval("\x01") + 468);
  1025.                   }
  1026.                   continue loop3;
  1027.                }
  1028.                if(eval("\x01") == 486)
  1029.                {
  1030.                   set("\x01",eval("\x01") + 351);
  1031.                   ┬º┬ºpush(true);
  1032.                   continue loop3;
  1033.                }
  1034.                if(eval("\x01") != 366)
  1035.                {
  1036.                   if(eval("\x01") == 331)
  1037.                   {
  1038.                      set("\x01",eval("\x01") + 178);
  1039.                      if(┬º┬ºpop())
  1040.                      {
  1041.                         set("\x01",eval("\x01") - 48);
  1042.                      }
  1043.                   }
  1044.                   else if(eval("\x01") == 714)
  1045.                   {
  1046.                      set("\x01",eval("\x01") - 466);
  1047.                      ┬º┬ºpush(true);
  1048.                   }
  1049.                   else if(eval("\x01") == 29)
  1050.                   {
  1051.                      set("\x01",eval("\x01") + 601);
  1052.                   }
  1053.                   else if(eval("\x01") == 648)
  1054.                   {
  1055.                      set("\x01",eval("\x01") + 224);
  1056.                   }
  1057.                   else if(eval("\x01") == 70)
  1058.                   {
  1059.                      set("\x01",eval("\x01") + 802);
  1060.                   }
  1061.                   else
  1062.                   {
  1063.                      if(eval("\x01") == 279)
  1064.                      {
  1065.                         set("\x01",eval("\x01") - 279);
  1066.                         break loop0;
  1067.                      }
  1068.                      if(eval("\x01") == 872)
  1069.                      {
  1070.                         set("\x01",eval("\x01") - 367);
  1071.                         ┬º┬ºpush(true);
  1072.                      }
  1073.                      else if(eval("\x01") == 993)
  1074.                      {
  1075.                         set("\x01",eval("\x01") - 810);
  1076.                      }
  1077.                      else
  1078.                      {
  1079.                         if(eval("\x01") != 837)
  1080.                         {
  1081.                            break loop0;
  1082.                         }
  1083.                         set("\x01",eval("\x01") + 122);
  1084.                         if(┬º┬ºpop())
  1085.                         {
  1086.                            set("\x01",eval("\x01") - 2);
  1087.                         }
  1088.                      }
  1089.                   }
  1090.                   continue loop3;
  1091.                }
  1092.                set("\x01",eval("\x01") + 328);
  1093.                while(true)
  1094.                {
  1095.                   if(┬º┬ºpop() == 192)
  1096.                   {
  1097.                      set("\x01",eval("\x01") - 153);
  1098.                      if(┬º┬ºpop())
  1099.                      {
  1100.                         set("\x01",eval("\x01") + 756);
  1101.                      }
  1102.                   }
  1103.                   else if(eval("\x01") == 374)
  1104.                   {
  1105.                      set("\x01",eval("\x01") + 484);
  1106.                      ┬º┬ºpush(true);
  1107.                   }
  1108.                   else
  1109.                   {
  1110.                      if(eval("\x01") == 72)
  1111.                      {
  1112.                         set("\x01",eval("\x01") + 353);
  1113.                         break loop0;
  1114.                      }
  1115.                      if(eval("\x01") == 715)
  1116.                      {
  1117.                         set("\x01",eval("\x01") + 166);
  1118.                      }
  1119.                      else if(eval("\x01") == 164)
  1120.                      {
  1121.                         set("\x01",eval("\x01") + 1);
  1122.                         if(┬º┬ºpop())
  1123.                         {
  1124.                            set("\x01",eval("\x01") - 148);
  1125.                         }
  1126.                      }
  1127.                      else if(eval("\x01") == 706)
  1128.                      {
  1129.                         set("\x01",eval("\x01") - 351);
  1130.                      }
  1131.                      else if(eval("\x01") == 287)
  1132.                      {
  1133.                         set("\x01",eval("\x01") + 68);
  1134.                      }
  1135.                      else
  1136.                      {
  1137.                         if(eval("\x01") == 456)
  1138.                         {
  1139.                            set("\x01",eval("\x01") + 355);
  1140.                            break loop0;
  1141.                         }
  1142.                         if(eval("\x01") == 985)
  1143.                         {
  1144.                            set("\x01",eval("\x01") - 766);
  1145.                            if(┬º┬ºpop())
  1146.                            {
  1147.                               set("\x01",eval("\x01") + 68);
  1148.                            }
  1149.                         }
  1150.                         else if(eval("\x01") == 204)
  1151.                         {
  1152.                            set("\x01",eval("\x01") + 214);
  1153.                         }
  1154.                         else if(eval("\x01") == 355)
  1155.                         {
  1156.                            set("\x01",eval("\x01") + 112);
  1157.                            ┬º┬ºpush(true);
  1158.                         }
  1159.                         else if(eval("\x01") == 893)
  1160.                         {
  1161.                            set("\x01",eval("\x01") - 229);
  1162.                         }
  1163.                         else if(eval("\x01") == 52)
  1164.                         {
  1165.                            set("\x01",eval("\x01") + 933);
  1166.                            ┬º┬ºpush(true);
  1167.                         }
  1168.                         else if(eval("\x01") == 156)
  1169.                         {
  1170.                            set("\x01",eval("\x01") + 486);
  1171.                         }
  1172.                         else if(eval("\x01") == 795)
  1173.                         {
  1174.                            set("\x01",eval("\x01") + 86);
  1175.                         }
  1176.                         else if(eval("\x01") == 881)
  1177.                         {
  1178.                            set("\x01",eval("\x01") - 717);
  1179.                            ┬º┬ºpush(true);
  1180.                         }
  1181.                         else if(eval("\x01") == 281)
  1182.                         {
  1183.                            set("\x01",eval("\x01") - 229);
  1184.                         }
  1185.                         else if(eval("\x01") == 811)
  1186.                         {
  1187.                            set("\x01",eval("\x01") - 759);
  1188.                         }
  1189.                         else if(eval("\x01") == 458)
  1190.                         {
  1191.                            set("\x01",eval("\x01") + 206);
  1192.                         }
  1193.                         else
  1194.                         {
  1195.                            if(eval("\x01") == 219)
  1196.                            {
  1197.                               set("\x01",eval("\x01") + 68);
  1198.                               break loop0;
  1199.                            }
  1200.                            if(eval("\x01") == 17)
  1201.                            {
  1202.                               set("\x01",eval("\x01") + 357);
  1203.                            }
  1204.                            else
  1205.                            {
  1206.                               if(eval("\x01") == 814)
  1207.                               {
  1208.                                  set("\x01",eval("\x01") - 610);
  1209.                                  break loop0;
  1210.                               }
  1211.                               if(eval("\x01") == 834)
  1212.                               {
  1213.                                  set("\x01",eval("\x01") - 416);
  1214.                               }
  1215.                               else if(eval("\x01") == 467)
  1216.                               {
  1217.                                  set("\x01",eval("\x01") - 459);
  1218.                                  if(┬º┬ºpop())
  1219.                                  {
  1220.                                     set("\x01",eval("\x01") + 148);
  1221.                                  }
  1222.                               }
  1223.                               else if(eval("\x01") == 425)
  1224.                               {
  1225.                                  set("\x01",eval("\x01") + 544);
  1226.                               }
  1227.                               else if(eval("\x01") == 29)
  1228.                               {
  1229.                                  set("\x01",eval("\x01") + 785);
  1230.                                  if(┬º┬ºpop())
  1231.                                  {
  1232.                                     set("\x01",eval("\x01") - 610);
  1233.                                  }
  1234.                               }
  1235.                               else
  1236.                               {
  1237.                                  if(eval("\x01") == 39)
  1238.                                  {
  1239.                                     set("\x01",eval("\x01") + 756);
  1240.                                     break loop0;
  1241.                                  }
  1242.                                  if(eval("\x01") == 8)
  1243.                                  {
  1244.                                     set("\x01",eval("\x01") + 148);
  1245.                                     gotoAndStop(47677);
  1246.                                     break loop0;
  1247.                                  }
  1248.                                  if(eval("\x01") == 858)
  1249.                                  {
  1250.                                     set("\x01",eval("\x01") - 786);
  1251.                                     if(┬º┬ºpop())
  1252.                                     {
  1253.                                        set("\x01",eval("\x01") + 353);
  1254.                                     }
  1255.                                  }
  1256.                                  else
  1257.                                  {
  1258.                                     if(eval("\x01") != 7)
  1259.                                     {
  1260.                                        if(eval("\x01") == 945)
  1261.                                        {
  1262.                                           set("\x01",eval("\x01") - 52);
  1263.                                           loop7:
  1264.                                           while(true)
  1265.                                           {
  1266.                                              set(┬º┬ºpop(),┬º┬ºpop() - ┬º┬ºpop());
  1267.                                              if(┬º┬ºpop())
  1268.                                              {
  1269.                                                 set("\x01",eval("\x01") + 415);
  1270.                                              }
  1271.                                              while(true)
  1272.                                              {
  1273.                                                 if(eval("\x01") == 629)
  1274.                                                 {
  1275.                                                    set("\x01",eval("\x01") + 224);
  1276.                                                    ┬º┬ºpush(true);
  1277.                                                 }
  1278.                                                 else if(eval("\x01") == 388)
  1279.                                                 {
  1280.                                                    set("\x01",eval("\x01") - 281);
  1281.                                                    ┬º┬ºpush(true);
  1282.                                                 }
  1283.                                                 else if(eval("\x01") == 853)
  1284.                                                 {
  1285.                                                    set("\x01",eval("\x01") + 74);
  1286.                                                    if(┬º┬ºpop())
  1287.                                                    {
  1288.                                                       set("\x01",eval("\x01") - 1);
  1289.                                                    }
  1290.                                                 }
  1291.                                                 else if(eval("\x01") == 926)
  1292.                                                 {
  1293.                                                    set("\x01",eval("\x01") - 554);
  1294.                                                 }
  1295.                                                 else if(eval("\x01") == 498)
  1296.                                                 {
  1297.                                                    set("\x01",eval("\x01") + 230);
  1298.                                                 }
  1299.                                                 else if(eval("\x01") == 691)
  1300.                                                 {
  1301.                                                    set("\x01",eval("\x01") - 303);
  1302.                                                 }
  1303.                                                 else if(eval("\x01") == 372)
  1304.                                                 {
  1305.                                                    set("\x01",eval("\x01") + 254);
  1306.                                                    ┬º┬ºpush(true);
  1307.                                                 }
  1308.                                                 else if(eval("\x01") == 728)
  1309.                                                 {
  1310.                                                    set("\x01",eval("\x01") + 166);
  1311.                                                    ┬º┬ºpush(true);
  1312.                                                 }
  1313.                                                 else if(eval("\x01") == 549)
  1314.                                                 {
  1315.                                                    set("\x01",eval("\x01") - 516);
  1316.                                                 }
  1317.                                                 else
  1318.                                                 {
  1319.                                                    if(eval("\x01") == 653)
  1320.                                                    {
  1321.                                                       break;
  1322.                                                    }
  1323.                                                    if(eval("\x01") == 894)
  1324.                                                    {
  1325.                                                       set("\x01",eval("\x01") - 241);
  1326.                                                       if(┬º┬ºpop())
  1327.                                                       {
  1328.                                                          set("\x01",eval("\x01") + 38);
  1329.                                                       }
  1330.                                                    }
  1331.                                                    else
  1332.                                                    {
  1333.                                                       if(eval("\x01") == 119)
  1334.                                                       {
  1335.                                                          set("\x01",eval("\x01") + 331);
  1336.                                                          break loop0;
  1337.                                                       }
  1338.                                                       if(eval("\x01") == 83)
  1339.                                                       {
  1340.                                                          set("\x01",eval("\x01") + 415);
  1341.                                                          break loop0;
  1342.                                                       }
  1343.                                                       if(eval("\x01") == 450)
  1344.                                                       {
  1345.                                                          set("\x01",eval("\x01") - 417);
  1346.                                                       }
  1347.                                                       else if(eval("\x01") == 107)
  1348.                                                       {
  1349.                                                          set("\x01",eval("\x01") + 12);
  1350.                                                          if(┬º┬ºpop())
  1351.                                                          {
  1352.                                                             set("\x01",eval("\x01") + 331);
  1353.                                                          }
  1354.                                                       }
  1355.                                                       else if(eval("\x01") == 277)
  1356.                                                       {
  1357.                                                          set("\x01",eval("\x01") + 111);
  1358.                                                       }
  1359.                                                       else
  1360.                                                       {
  1361.                                                          if(eval("\x01") == 927)
  1362.                                                          {
  1363.                                                             break loop7;
  1364.                                                          }
  1365.                                                          if(eval("\x01") == 369)
  1366.                                                          {
  1367.                                                             set("\x01",eval("\x01") + 359);
  1368.                                                          }
  1369.                                                          else
  1370.                                                          {
  1371.                                                             if(eval("\x01") == 33)
  1372.                                                             {
  1373.                                                                set("\x01",eval("\x01") + 531);
  1374.                                                                this.tail_mc.gotoAndPlay(2);
  1375.                                                                break loop0;
  1376.                                                             }
  1377.                                                             if(eval("\x01") == 626)
  1378.                                                             {
  1379.                                                                continue loop7;
  1380.                                                             }
  1381.                                                             if(eval("\x01") == 564)
  1382.                                                             {
  1383.                                                                set("\x01",eval("\x01") - 564);
  1384.                                                                break loop0;
  1385.                                                             }
  1386.                                                             if(eval("\x01") != 665)
  1387.                                                             {
  1388.                                                                break loop0;
  1389.                                                             }
  1390.                                                             set("\x01",eval("\x01") - 293);
  1391.                                                          }
  1392.                                                       }
  1393.                                                    }
  1394.                                                 }
  1395.                                              }
  1396.                                              continue loop4;
  1397.                                           }
  1398.                                           set("\x01",eval("\x01") - 1);
  1399.                                           break loop0;
  1400.                                        }
  1401.                                        if(eval("\x01") == 117)
  1402.                                        {
  1403.                                           set("\x01",eval("\x01") - 117);
  1404.                                           break loop0;
  1405.                                        }
  1406.                                        break loop0;
  1407.                                     }
  1408.                                     set("\x01",eval("\x01") + 635);
  1409.                                  }
  1410.                               }
  1411.                            }
  1412.                         }
  1413.                      }
  1414.                   }
  1415.                   while(true)
  1416.                   {
  1417.                      if(eval("\x01") == 122)
  1418.                      {
  1419.                         set("\x01",eval("\x01") + 70);
  1420.                         ┬º┬ºpush(true);
  1421.                      }
  1422.                      else if(eval("\x01") == 969)
  1423.                      {
  1424.                         set("\x01",eval("\x01") - 698);
  1425.                         ┬º┬ºpush(true);
  1426.                      }
  1427.                      else if(eval("\x01") == 361)
  1428.                      {
  1429.                         set("\x01",eval("\x01") + 608);
  1430.                      }
  1431.                      else if(eval("\x01") == 876)
  1432.                      {
  1433.                         set("\x01",eval("\x01") + 69);
  1434.                         if(┬º┬ºpop())
  1435.                         {
  1436.                            set("\x01",eval("\x01") - 52);
  1437.                         }
  1438.                      }
  1439.                      else
  1440.                      {
  1441.                         if(eval("\x01") == 165)
  1442.                         {
  1443.                            set("\x01",eval("\x01") - 148);
  1444.                            break loop0;
  1445.                         }
  1446.                         if(eval("\x01") == 325)
  1447.                         {
  1448.                            set("\x01",eval("\x01") + 49);
  1449.                         }
  1450.                         else if(eval("\x01") == 271)
  1451.                         {
  1452.                            set("\x01",eval("\x01") + 185);
  1453.                            if(┬º┬ºpop())
  1454.                            {
  1455.                               set("\x01",eval("\x01") + 355);
  1456.                            }
  1457.                         }
  1458.                         else if(eval("\x01") == 418)
  1459.                         {
  1460.                            set("\x01",eval("\x01") + 458);
  1461.                            ┬º┬ºpush(true);
  1462.                         }
  1463.                         else
  1464.                         {
  1465.                            if(eval("\x01") == 664)
  1466.                            {
  1467.                               set("\x01",eval("\x01") - 547);
  1468.                               this.tail_mc.gotoAndPlay(22);
  1469.                               break loop0;
  1470.                            }
  1471.                            if(eval("\x01") != 642)
  1472.                            {
  1473.                               break;
  1474.                            }
  1475.                            set("\x01",eval("\x01") - 613);
  1476.                            ┬º┬ºpush(true);
  1477.                         }
  1478.                      }
  1479.                   }
  1480.                }
  1481.             }
  1482.             continue loop2;
  1483.          }
  1484.       }
  1485.    }
  1486. }
  1487.